import axios from 'axios'
import { Toast } from 'mint-ui'
// import store from '@/store/index'
import Qs from 'qs'
import { getToken } from '@/utils/store/token'
import { isHaveWhiteSSoUrl } from '@/utils/isJudge'
const BASE_API = process.env.BASE_API
const API_UAA_ROOT = process.env.API_UAA_ROOT
const TMS_API = process.env.TMS_API
const DEVOP_API = process.env.DEVOP_API
const LSPM_MDM_API = process.env.LSPM_MDM_API
// 竞价
const LISA_FPS_API = process.env.LISA_FPS_API
const FLEET = process.env.FLEET
const CODE = process.env.CODE



// 'Access-Control-Allow-Origin': '*',
// withCredentials: true, // 带cookie请求
// 创建ssoaxios实例
export const ssoService = axios.create({
  baseURL: API_UAA_ROOT, // api的UAA_API 单点登录
  timeout: 5000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
})

// 添加请求拦截器
ssoService.interceptors.request.use((config) => {
  const ssoToken = getToken()
  // 检测出url 是/oauth/token 则ssoService请求不带token;
  // 以此避免 登录有token后再做其他操作(例重新登陆)时 有请求/oauth/token 的操作，导致报401 options的错误
  // const white_router_list = ['/oauth/token', '/account/signin/smscode']
  const white_router1 = '/oauth/token'
  const is_no_token1 = isHaveWhiteSSoUrl(config, white_router1)
  if (getToken()) {
    if (is_no_token1) {
      config.headers = {
        Accept: 'application/json, text/plain, */*'
      }
    } else {
      config.headers['Authorization'] = ssoToken // 让每个请求携带自定义token 请根据实际情况自行修改
    }
  }
  return config
}, (error) => {
  // 对请求错误做些什么
  return Promise.reject(error)
})

// 添加响应拦截器
ssoService.interceptors.response.use((response) => {
  // 对响应数据做点什么
  return response
}, (error) => {
  // 对响应错误做点什么
  // console.log('ssoService-error.response', error.response)
  if (error && error.response) {
    switch (error.response.status) {
      case 400: error.message = '账号或密码错误' // (400)
        break
      case 401: error.message = '未授权或授权已过期，请重新登录' // (401)
        break
      // case 403: error.message = '拒绝访问(403)'
      //   break
      // case 404: error.message = '请求出错(404)'
      //   break
      // case 408: error.message = '请求超时(408)'
      //   break
      // case 500: error.message = '服务器错误(500)'
      //   break
      // case 501: error.message = '服务未实现(501)'
      //   break
      // case 502: error.message = '网络错误(502)'
      //   break
      // case 503: error.message = '服务不可用(503)'
      //   break
      // case 504: error.message = '网络超时(504)'
      //   break
      // case 505: error.message = 'HTTP版本不受支持(505)'
      //   break
      default: error.message = `连接出错(${error.response.status})!`
    }
    if (error.response.config) {
      const white_router1 = '/oauth/token'
      const is_change_message1 = isHaveWhiteSSoUrl(error.response.config, white_router1)
      if (is_change_message1) {
        if (error.response.status === 500) {
          error.message = '账号或验证码输入错误！'
        }
      }
    }
    Toast({
      message: error.message,
      duration: 2000
    })
  } else {
    error.message = '连接服务器失败!'
    Toast({
      message: error.message,
      duration: 2000
    })
  }
  return Promise.reject(error)
})

// 创建normalaxios实例
export const normalService = axios.create({
  baseURL: BASE_API, // api的base_url
  timeout: 10000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
})

// 添加请求拦截器
normalService.interceptors.request.use((config) => {
  // console.log('此处getToken()是normalService请求头加token')
  const ssoToken = getToken()
  if (getToken()) {
    config.headers['Authorization'] = ssoToken // 让每个请求携带自定义token 请根据实际情况自行修改
  }
  // console.log('ssoService- config', config)
  return config
}, function(error) {
  // 对请求错误做些什么
  return Promise.reject(error)
})

// 添加响应拦截器
normalService.interceptors.response.use(
  response => {
    /**
     * code为非20000是抛错 可结合自己业务进行修改
     */
    // console.log('normalService-error', response)
    const res = response.data
    if (res.code !== 0) {
      if (res.code === -1) {
        Toast({
          message: res.message || '系统繁忙，请稍候再试',
          duration: 2000
        })
      } else {
        Toast({
          message: '系统繁忙，请稍候再试',
          duration: 1500
        })
      }
      return Promise.reject('error')
    } else {
      return response.data
    }
  },
  error => {
    // console.log(error)// for debug
    // console.log('normalService', 111, 'error.status', error.response)
    // if (error.message === 'Network Error') {
    //   Toast({
    //     message: '网络异常，请联系网络管理员',
    //     // type: 'error',
    //     duration: 5 * 1000
    //   })
    // } else {
    //   Toast({
    //     message: error.message,
    //     // type: 'error',
    //     duration: 5 * 1000
    //   })
    // }
    // console.log('normalService-error', error.response)
    return Promise.reject(error)
  }
)


// 创建TMSaxios实例
export const tmsService = axios.create({
  baseURL: TMS_API, // api的base_url
  timeout: 50000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
})

// 添加请求拦截器
tmsService.interceptors.request.use((config) => {
  const ssoToken = getToken()
  if (getToken()) {
    console.log('tmsService- config', config)
    config.headers['Authorization'] = ssoToken // 让每个请求携带自定义token 请根据实际情况自行修改
  }
  // console.log('ssoService- config', config)
  return config
}, function(error) {
  // 对请求错误做些什么
  return Promise.reject(error)
})

// 添加响应拦截器
tmsService.interceptors.response.use((response) => {
  // 对响应数据做点什么
  // console.log('tmsService-response-response', response)
  const res = response.data
  if (res.code !== 0) {
    if (res.code === -1) {
      Toast({
        message: res.message || '系统繁忙，请稍候再试',
        duration: 2000
      })
    } else {
      Toast({
        message: '系统繁忙，请稍候再试',
        duration: 1500
      })
    }
    return Promise.reject('error')
  } else {
    return response.data
  }
}, (error) => {
  // 对响应错误做点什么
  // console.log('tmsService-response-error', error)
  // console.log('tmsService', 111)
  // if (error.response.status === 401) {
  //   console.log('tmsService', 222)
  //   store.dispatch('LoginRefresh')
  //   return Promise.reject(error)
  // }
  return Promise.reject(error)
})


// 创建devopaxios实例
export const devopService = axios.create({
  baseURL: DEVOP_API, // api的base_url
  timeout: 50000, // 请求超时时间
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded'
  },
  transformRequest: [data => Qs.stringify(data, {
    indices: false
  })] // indices 表示在转换数组时不加序号
})

// 添加请求拦截器
devopService.interceptors.request.use((config) => {
  // console.log('此处getToken()是devopService请求头加token')
  const ssoToken = getToken()
  if (getToken()) {
    config.headers['Authorization'] = ssoToken // 让每个请求携带自定义token 请根据实际情况自行修改
  }
  // console.log('devopService- config', config)
  return config
}, function(error) {
  // 对请求错误做些什么
  return Promise.reject(error)
})

// 添加响应拦截器
devopService.interceptors.response.use((response) => {
  // 对响应数据做点什么
  const white_router1 = '/img/driverlicenseinfo' // 驾照识别api返回的message处理
  const is_change_message1 = isHaveWhiteSSoUrl(response.config, white_router1)
  // console.log('cur_str', cur_str, 'res_check', res_check)
  const res = response.data
  if (res.code !== 0) {
    if (is_change_message1) {
      if (res.code === -1) {
        Toast({
          message: '驾照信息识别失败',
          duration: 2000
        })
        return
      } else {
        Toast({
          message: '系统繁忙，请稍候再试',
          duration: 1500
        })
        return
      }
    }
    if (res.code === -1) {
      Toast({
        message: res.message || '系统繁忙，请稍候再试',
        duration: 2000
      })
    } else {
      Toast({
        message: '系统繁忙，请稍候再试',
        duration: 1500
      })
    }
    return Promise.reject('error')
  } else {
    return response.data
  }
}, (error) => {
  // 对响应错误做点什么
  return Promise.reject(error)
})


// 创建 mdmService
export const mdmService = axios.create({
  baseURL: LSPM_MDM_API, // api的base_url
  timeout: 50000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
})
// 添加请求拦截器
mdmService.interceptors.request.use((config) => {
  const ssoToken = getToken()
  if (getToken()) {
    console.log('mdmService- config', config)
    config.headers['Authorization'] = ssoToken // 让每个请求携带自定义token 请根据实际情况自行修改
  }
  return config
}, function(error) {
  // 对请求错误做些什么
  return Promise.reject(error)
})

// 添加响应拦截器
mdmService.interceptors.response.use((response) => {
  // 对响应数据做点什么
  const res = response.data
  if (res.code !== 0) {
    if (res.code === -1) {
      Toast({
        message: res.message || '系统繁忙，请稍候再试',
        duration: 2000
      })
    } else {
      Toast({
        message: '系统繁忙，请稍候再试',
        duration: 1500
      })
    }
    return Promise.reject('error')
  } else {
    return response.data
  }
}, (error) => {
  return Promise.reject(error)
})


// 全员采购-获取车队信息carService
export const carService = axios.create({
  baseURL: BASE_API, // api的base_url
  timeout: 50000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
})
// 添加请求拦截器
carService.interceptors.request.use((config) => {
  const carToken = getToken()
  if (getToken()) {
    console.log('carService- config', config)
    config.headers['Authorization'] = carToken // 让每个请求携带自定义token 请根据实际情况自行修改
  }
  return config
}, function(error) {
  // 对请求错误做些什么
  return Promise.reject(error)
})

// 添加响应拦截器
carService.interceptors.response.use((response) => {
  return response.data
}, (error) => {
  return Promise.reject(error)
})


// 全员采购FPSAxios
export const fpxService = axios.create({
  baseURL: LISA_FPS_API, // api的base_url
  timeout: 50000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
})
// 添加请求拦截器
fpxService.interceptors.request.use((config) => {
  const fpxToken = getToken()
  if (getToken()) {
    console.log('fpxService- config', config)
    config.headers['Authorization'] = fpxToken // 让每个请求携带自定义token 请根据实际情况自行修改
  }
  return config
}, function(error) {
  // 对请求错误做些什么
  return Promise.reject(error)
})

// 添加响应拦截器
fpxService.interceptors.response.use((response) => {
  return response.data
}, (error) => {
  return Promise.reject(error)
})

// 车队下的车辆信息fleetService
export const fleetService = axios.create({
  baseURL: FLEET, // api的base_url
  timeout: 50000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
})
// 添加请求拦截器
fleetService.interceptors.request.use((config) => {
  const fleetToken = getToken()
  if (getToken()) {
    console.log('fleetService- config', config)
    config.headers['Authorization'] = fleetToken // 让每个请求携带自定义token 请根据实际情况自行修改
  }
  return config
}, function(error) {
  // 对请求错误做些什么
  return Promise.reject(error)
})

// 添加响应拦截器
fleetService.interceptors.response.use((response) => {
  return response.data
}, (error) => {
  return Promise.reject(error)
})


// 提交微信code和获取openID
export const codeService = axios.create({
  baseURL: CODE,
  timeout: 50000,
  headers: {
    'Content-Type': 'application/json'
  }
})
codeService.interceptors.request.use((config) => {
  const codeToken = getToken()
  if (getToken()) {
    console.log('fleetService- config', config)
    config.headers['Authorization'] = codeToken // 让每个请求携带自定义token 请根据实际情况自行修改
  }
  return config
}, function(error) {
  return Promise.reject(error)
})

codeService.interceptors.response.use((response) => {
  return response.data
}, (error) => {
  return Promise.reject(error)
})



